<?php

namespace app\adminapi\controller;

use app\model\AdminsModel;
use app\model\RolePermissionModel;
use app\model\PermissionModel;
use app\model\RolesModel;
use support\Redis;
use Webman\Http\Request;

class Auth extends BaseAdminApi
{
    /**
     * 不需要登录的方法
     * @var array
     */
    protected $noNeedLogin = ['login', 'logout'];

    /**
     * 不需要权限验证的方法（已登录但不验证具体权限）
     * @var array
     */
    protected $noNeedPermission = ['getInfo', 'getMenus'];

    /**
     * 管理员登录
     */
    public function login(Request $request)
    {
        $params = $request->post();

        $validator = validator($params, [
            'username' => 'required|min:4|max:32',
            'password' => ['required', 'min:6', 'regex:/^(?=.*[A-Za-z])(?=.*\d)(?=.*[@$!%*#?&])[A-Za-z\d@$!%*#?&]+$/'],
        ], [
            'username.required' => '请填写用户名',
            'password.required' => '请填写密码',
            'password.regex' => '密码必须包含字母、数字和特殊字符',
        ]);

        if ($validator->fails()) {
            return fail($validator->errors()->first());
        }

        $admin = AdminsModel::where('username', $params['username'])->first();

        if ($admin) {
            $password = $admin->password;

            //验证密码，通过则登录成功
//            return data(password_hash($params['password'], PASSWORD_DEFAULT));
            if (password_verify($params['password'], $password)) {
                $token = randomString();

                $admin->last_login_time = date('Y-m-d H:i:s');
                $admin->last_login_ip = $request->getRealIp();
                $admin->save();

                $ttl = 3600; //一个小时

                if ($params['remember']) {
                    $ttl = 3600 * 24 * 7; //七天
                }

                Redis::setex($token, $ttl, $admin->id);

                return data(["token" => $token, "info" => $admin]);
            } else {
                //密码不一致，登录失败
                return fail("用户名或密码错误！");
            }
        }

        return fail("用户名或密码错误！");
    }

    public function logout(Request $request)
    {
        $token = $request->header('authorization');

        Redis::del($token);

        return success();
    }


    /**
     * 获取当前登录管理员信息
     * @param Request $request
     * @return \support\Response
     */
    public function getInfo(Request $request)
    {
        $adminId = $request->admin_id;

        $admin = AdminsModel::find($adminId);

        return data($admin);
    }

    /**
     * 获取当前登录用户的菜单
     * @param Request $request
     * @return \support\Response
     */
    public function getMenus(Request $request)
    {
        $adminId = $request->admin_id;

        $admin = AdminsModel::find($adminId);

        if (!$admin) {
            return fail('用户不存在');
        }

        $role = RolesModel::find($admin->role_id);

        //如果为创建人角色，则获取系统全权限
        if ($role->is_founder == 1) {
            $menuIds = PermissionModel::where("type", 1)->pluck('id')->toArray();
        } else {
            $where = [
                ["role_id", "=", $admin->role_id]
            ];

            $menuIds = RolePermissionModel::where($where)->pluck('menu_id')->toArray();
        }

        // 获取菜单信息并构建树形结构
        $menuWhere = [
            ["status", "=", 1],
            ["type", "=", 1]
        ];

        $menus = PermissionModel::whereIn('id', $menuIds)
            ->where($menuWhere)
            ->orderBy('sort', 'asc')
            ->get();

        $menusTree = buildTreeData($menus, '0');

        return data($menusTree);
    }

    public function getAllMenus(Request $request)
    {
        $menus = PermissionModel::orderBy('sort', 'asc')->get();

        $menusTree = buildTreeData($menus, '0');

        return data($menusTree);
    }

    public function getParentMenus(Request $request)
    {
        $menus = PermissionModel::where('parent_id', 0)->orderBy('sort', 'asc')->get();

        $menusTree = buildTreeData($menus, '0');

        return data($menusTree);
    }

    public function saveMenus(Request $request)
    {
        $params = $request->only(['id','title','name','path','component','status','icon','parent_id','sort','type']);

        // 验证参数
        $validator = validator($params, [
            'title' => 'required|max:6',
            'name' => 'required|max:100',
            'path' => 'required|max:100',
            'component' => 'nullable|max:100',
            'status' => 'required|in:0,1',
            'icon' => 'nullable|max:50',
        ], [
            'title.required' => '菜单标题不能为空',
            'title.max' => '菜单标题不能超过6个字符',
            'name.required' => '菜单标识不能为空',
            'name.max' => '菜单标识不能超过10个字符',
            'path.required' => '访问URL不能为空',
            'path.max' => '访问URL不能超过100个字符',
            'component.max' => '组件路径不能超过100个字符',
            'status.required' => '状态不能为空',
            'status.in' => '状态值只能是0或1',
            'icon.max' => '图标不能超过50个字符'
        ]);

        if ($validator->fails()) {
            return fail($validator->errors()->first());
        }

        $params["meta"] = ["title" => $params["title"]];

        try {
            // 判断是新增还是编辑
            if (isset($params['id']) && !empty($params['id'])) {
                // 编辑菜单
                $menu = PermissionModel::find($params['id']);
                if (!$menu) {
                    return fail('菜单不存在');
                }

                // 检查菜单标识是否重复（排除自己）
                $existMenu = PermissionModel::where('name', $params['name'])
                    ->where('id', '!=', $params['id'])
                    ->first();
                if ($existMenu) {
                    return fail('菜单标识已存在');
                }

                // 更新菜单
                $menu->update($params);

                return success('菜单更新成功');
            } else {
                // 新增菜单
                // 检查菜单标识是否重复
                $existMenu = PermissionModel::where('name', $params['name'])->first();
                if ($existMenu) {
                    return fail('菜单标识已存在');
                }

                // 创建新菜单
                PermissionModel::create($params);

                return success('菜单创建成功');
            }
        } catch (\Exception $e) {
            return fail('操作失败：' . $e->getMessage());
        }
    }

    public function deleteMenus(Request $request)
    {
        $params = $request->post();

        // 验证参数
        if (!isset($params['id']) || empty($params['id'])) {
            return fail('请提供要删除的菜单ID');
        }

        $menuId = $params['id'];

        try {
            // 检查菜单是否存在
            $menu = PermissionModel::find($menuId);
            if (!$menu) {
                return fail('菜单不存在');
            }

            // 检查是否有子菜单
            $hasChildren = PermissionModel::where('parent_id', $menuId)->exists();
            if ($hasChildren) {
                return fail('该菜单下存在子菜单，请先删除子菜单');
            }

            // 检查菜单是否被角色使用
            $isUsedByRole = RolePermissionModel::where('menu_id', $menuId)->exists();
            if ($isUsedByRole) {
                // 删除角色菜单关联
                RolePermissionModel::where('menu_id', $menuId)->delete();
            }

            // 删除菜单
            $menu->delete();

            return success('菜单删除成功');
        } catch (\Exception $e) {
            return fail('删除失败：' . $e->getMessage());
        }
    }

    /**
     * 获取角色列表
     */
    public function getRoles(Request $request)
    {
        $params = $request->get();
        $pageSize = $params['pageSize'] ?? 10;

        $query = RolesModel::query();

        // 搜索条件
        if (!empty($params['name'])) {
            $query->where('name', 'like', '%' . $params['name'] . '%');
        }

        $paginate = $query->orderBy('created_at', 'desc')
            ->paginate($pageSize);

        return dataByPage($paginate);
    }

    /**
     * 保存角色
     */
    public function saveRole(Request $request)
    {
        $params = $request->post();

        $validator = validator($params, [
            'name' => 'required|max:50',
            'description' => 'nullable|max:255',
            'status' => 'required|in:0,1',
            'menu_ids' => 'nullable|array'
        ], [
            'name.required' => '角色名称不能为空',
            'name.max' => '角色名称不能超过50个字符',
            'description.max' => '角色描述不能超过255个字符',
            'status.required' => '状态不能为空',
            'status.in' => '状态值只能是0或1',
            'menu_ids.array' => '菜单权限必须是数组格式'
        ]);

        if ($validator->fails()) {
            return fail($validator->errors()->first());
        }

        try {
            if (isset($params['id']) && !empty($params['id'])) {
                // 编辑角色
                $role = RolesModel::find($params['id']);
                if (!$role) {
                    return fail('角色不存在');
                }

                // 检查角色名是否重复（排除自己）
                $existRole = RolesModel::where('name', $params['name'])
                    ->where('id', '!=', $params['id'])
                    ->first();
                if ($existRole) {
                    return fail('角色名称已存在');
                }

                $role->update([
                    'name' => $params['name'],
                    'description' => $params['description'] ?? '',
                    'status' => $params['status']
                ]);

                $message = '角色更新成功';
            } else {
                // 新增角色
                $existRole = RolesModel::where('name', $params['name'])->first();
                if ($existRole) {
                    return fail('角色名称已存在');
                }

                RolesModel::create([
                    'name' => $params['name'],
                    'description' => $params['description'] ?? '',
                    'status' => $params['status']
                ]);

                $message = '角色创建成功';
            }

            return success($message);
        } catch (\Exception $e) {
            return fail('操作失败：' . $e->getMessage());
        }
    }

    /**
     * 删除角色
     */
    public function deleteRole(Request $request)
    {
        $params = $request->post();

        if (!isset($params['id']) || empty($params['id'])) {
            return fail('请提供要删除的角色ID');
        }

        try {
            $role = RolesModel::find($params['id']);
            if (!$role) {
                return fail('角色不存在');
            }

            // 检查角色是否被管理员使用
            $isUsed = AdminsModel::where('role_id', $params['id'])->exists();
            if ($isUsed) {
                return fail('该角色正在被管理员使用，无法删除');
            }

            // 删除角色菜单关联
            RolePermissionModel::where('role_id', $params['id'])->delete();

            // 删除角色
            $role->delete();

            return success('角色删除成功');
        } catch (\Exception $e) {
            return fail('删除失败：' . $e->getMessage());
        }
    }

    /**
     * 获取角色菜单权限
     */
    public function getRoleMenus(Request $request)
    {
        $params = $request->get();

        if (!isset($params['role_id']) || empty($params['role_id'])) {
            return fail('请提供角色ID');
        }

        $menuIds = RolePermissionModel::where('role_id', $params['role_id'])
            ->pluck('menu_id')
            ->toArray();

        return data($menuIds);
    }

    /**
     * 保存角色权限
     */
    public function saveRolePermission(Request $request)
    {
        $params = $request->post();

        // 验证参数
        $validator = validator($params, [
            'id' => 'required|integer',
            'menu_ids' => 'required|array'
        ], [
            'id.required' => '角色ID不能为空',
            'id.integer' => '角色ID必须是整数',
            'menu_ids.required' => '菜单权限不能为空',
            'menu_ids.array' => '菜单权限必须是数组格式'
        ]);

        if ($validator->fails()) {
            return fail($validator->errors()->first());
        }

        try {
            // 检查角色是否存在
            $role = RolesModel::find($params['id']);
            if (!$role) {
                return fail('角色不存在');
            }

            // 检查是否为创建人角色
            if ($role->is_founder == 1) {
                return fail('系统创建人角色权限不可修改');
            }

            // 删除原有权限
            RolePermissionModel::where('role_id', $params['id'])->delete();

            // 添加新权限
            if (!empty($params['menu_ids'])) {
                $roleMenus = [];
                foreach ($params['menu_ids'] as $menuId) {
                    $roleMenus[] = [
                        'id' => randomString(),
                        'role_id' => $params['id'],
                        'menu_id' => $menuId
                    ];
                }
                RolePermissionModel::insert($roleMenus);
            }

            return success('权限设置成功');
        } catch (\Exception $e) {
            return fail('操作失败：' . $e->getMessage());
        }
    }

    /**
     * 获取用户列表
     */
    public function getUsers(Request $request)
    {
        $params = $request->get();
        $pageSize = $params['pageSize'] ?? 10;

        $query = AdminsModel::with(['role' => function ($query) {
            $query->select('id', 'name');
        }]);

        // 搜索条件
        if (!empty($params['username'])) {
            $query->where('username', 'like', '%' . $params['username'] . '%');
        }

        if (!empty($params['real_name'])) {
            $query->where('real_name', 'like', '%' . $params['real_name'] . '%');
        }

        if (isset($params['status']) && $params['status'] !== '') {
            $query->where('status', $params['status']);
        }

        $paginate = $query->orderBy('created_at', 'desc')
            ->paginate($pageSize);

        return dataByPage($paginate);
    }

    /**
     * 保存用户
     */
    public function saveUser(Request $request)
    {
        $params = $request->post();

        $rules = [
            'username' => 'required|min:4|max:32',
            'real_name' => 'required|max:50',
            'email' => 'nullable|email|max:100',
            'role_id' => 'required|exists:roles,id',
            'status' => 'required|in:0,1'
        ];

        $messages = [
            'username.required' => '用户名不能为空',
            'username.min' => '用户名至少4个字符',
            'username.max' => '用户名不能超过32个字符',
            'real_name.required' => '姓名不能为空',
            'real_name.max' => '姓名不能超过50个字符',
            'email.email' => '邮箱格式不正确',
            'email.max' => '邮箱不能超过100个字符',
            'role_id.required' => '角色不能为空',
            'role_id.exists' => '角色不存在',
            'status.required' => '状态不能为空',
            'status.in' => '状态值只能是0或1'
        ];

        // 如果是新增用户，密码为必填
        if (!isset($params['id']) || empty($params['id'])) {
            $rules['password'] = ['required', 'min:6', 'regex:/^(?=.*[A-Za-z])(?=.*\d)(?=.*[@$!%*#?&])[A-Za-z\d@$!%*#?&]+$/'];
            $messages['password.required'] = '密码不能为空';
            $messages['password.min'] = '密码至少6个字符';
            $messages['password.regex'] = '密码必须包含字母、数字和特殊字符';
        } else {
            // 编辑时密码可选
            if (!empty($params['password'])) {
                $rules['password'] = ['min:6', 'regex:/^(?=.*[A-Za-z])(?=.*\d)(?=.*[@$!%*#?&])[A-Za-z\d@$!%*#?&]+$/'];
                $messages['password.min'] = '密码至少6个字符';
                $messages['password.regex'] = '密码必须包含字母、数字和特殊字符';
            }
        }

        $validator = validator($params, $rules, $messages);

        if ($validator->fails()) {
            return fail($validator->errors()->first());
        }

        try {
            if (isset($params['id']) && !empty($params['id'])) {
                // 编辑用户
                $user = AdminsModel::find($params['id']);
                if (!$user) {
                    return fail('用户不存在');
                }

                // 检查用户名是否重复（排除自己）
                $existUser = AdminsModel::where('username', $params['username'])
                    ->where('id', '!=', $params['id'])
                    ->first();
                if ($existUser) {
                    return fail('用户名已存在');
                }

                // 检查邮箱是否重复（排除自己）
                if (!empty($params['email'])) {
                    $existEmail = AdminsModel::where('email', $params['email'])
                        ->where('id', '!=', $params['id'])
                        ->first();
                    if ($existEmail) {
                        return fail('邮箱已存在');
                    }
                }

                $updateData = [
                    'username' => $params['username'],
                    'real_name' => $params['real_name'],
                    'email' => $params['email'] ?? null,
                    'role_id' => $params['role_id'],
                    'status' => $params['status']
                ];

                // 如果提供了新密码，则更新密码
                if (!empty($params['password'])) {
                    $updateData['password'] = password_hash($params['password'], PASSWORD_DEFAULT);
                }

                $user->update($updateData);

                return success('用户更新成功');
            } else {
                // 新增用户
                // 检查用户名是否重复
                $existUser = AdminsModel::where('username', $params['username'])->first();
                if ($existUser) {
                    return fail('用户名已存在');
                }

                // 检查邮箱是否重复
                if (!empty($params['email'])) {
                    $existEmail = AdminsModel::where('email', $params['email'])->first();
                    if ($existEmail) {
                        return fail('邮箱已存在');
                    }
                }

                AdminsModel::create([
                    'id' => randomString(),
                    'username' => $params['username'],
                    'real_name' => $params['real_name'],
                    'email' => $params['email'] ?? null,
                    'password' => password_hash($params['password'], PASSWORD_DEFAULT),
                    'role_id' => $params['role_id'],
                    'status' => $params['status'],
                ]);

                return success('用户创建成功');
            }
        } catch (\Exception $e) {
            return fail('操作失败：' . $e->getMessage());
        }
    }

    /**
     * 删除用户
     */
    public function deleteUser(Request $request)
    {
        $params = $request->post();

        if (!isset($params['id']) || empty($params['id'])) {
            return fail('请提供要删除的用户ID');
        }

        try {
            $user = AdminsModel::find($params['id']);
            if (!$user) {
                return fail('用户不存在');
            }

            // 检查是否为当前登录用户
            if ($user->id == $request->admin_id) {
                return fail('不能删除当前登录用户');
            }

            // 检查用户角色是否为创建人
            $role = RolesModel::find($user->role_id);
            if ($role && $role->is_founder == 1) {
                return fail('不能删除系统创建人');
            }

            // 删除用户
            $user->delete();

            return success('用户删除成功');
        } catch (\Exception $e) {
            return fail('删除失败：' . $e->getMessage());
        }
    }

    /**
     * 更新个人信息
     */
    public function updateProfile(Request $request)
    {
        $params = $request->post();
        $adminId = $request->admin_id;

        $validator = validator($params, [
            'real_name' => 'nullable|max:20',
            'email' => 'nullable|email|max:100',

            'bio' => 'nullable|max:200'
        ], [
            'real_name.max' => '真实姓名不能超过20个字符',
            'email.email' => '邮箱格式不正确',
            'email.max' => '邮箱不能超过100个字符',

            'bio.max' => '个人简介不能超过200个字符'
        ]);

        if ($validator->fails()) {
            return fail($validator->errors()->first());
        }

        try {
            $admin = AdminsModel::find($adminId);
            if (!$admin) {
                return fail('用户不存在');
            }

            // 检查邮箱是否重复（排除自己）
            if (!empty($params['email'])) {
                $existEmail = AdminsModel::where('email', $params['email'])
                    ->where('id', '!=', $adminId)
                    ->first();
                if ($existEmail) {
                    return fail('邮箱已被其他用户使用');
                }
            }



            $admin->update([
                'real_name' => $params['real_name'] ?? $admin->real_name,
                'email' => $params['email'] ?? $admin->email,

                'bio' => $params['bio'] ?? $admin->bio
            ]);

            return success('个人信息更新成功');
        } catch (\Exception $e) {
            return fail('更新失败：' . $e->getMessage());
        }
    }

    /**
     * 修改密码
     */
    public function changePassword(Request $request)
    {
        $params = $request->post();
        $adminId = $request->admin_id;

        $validator = validator($params, [
            'current_password' => 'required',
            'new_password' => ['required', 'min:6', 'max:20', 'regex:/^(?=.*[A-Za-z])(?=.*\d)(?=.*[@$!%*#?&])[A-Za-z\d@$!%*#?&]+$/'],
            'confirm_password' => 'required|same:new_password'
        ], [
            'current_password.required' => '请输入当前密码',
            'new_password.required' => '请输入新密码',
            'new_password.min' => '新密码至少6个字符',
            'new_password.max' => '新密码不能超过20个字符',
            'new_password.regex' => '新密码必须包含字母、数字和特殊字符',
            'confirm_password.required' => '请确认新密码',
            'confirm_password.same' => '两次输入的密码不一致'
        ]);

        if ($validator->fails()) {
            return fail($validator->errors()->first());
        }

        try {
            $admin = AdminsModel::find($adminId);
            if (!$admin) {
                return fail('用户不存在');
            }

            // 验证当前密码
            if (!password_verify($params['current_password'], $admin->password)) {
                return fail('当前密码不正确');
            }

            // 检查新密码是否与当前密码相同
            if (password_verify($params['new_password'], $admin->password)) {
                return fail('新密码不能与当前密码相同');
            }

            // 更新密码
            $admin->update([
                'password' => password_hash($params['new_password'], PASSWORD_DEFAULT)
            ]);

            return success('密码修改成功');
        } catch (\Exception $e) {
            return fail('修改失败：' . $e->getMessage());
        }
    }

    /**
     * 上传头像
     */
    public function uploadAvatar(Request $request)
    {
        $adminId = $request->admin_id;
        
        try {
            $file = $request->file('avatar');
            if (!$file) {
                return fail('请选择要上传的头像文件');
            }

            // 验证文件类型
            $allowedTypes = ['image/jpeg', 'image/png', 'image/gif'];
            if (!in_array($file->getMimeType(), $allowedTypes)) {
                return fail('只支持 JPG、PNG、GIF 格式的图片');
            }

            // 验证文件大小（2MB）
            if ($file->getSize() > 2 * 1024 * 1024) {
                return fail('头像文件大小不能超过2MB');
            }

            // 生成文件名
            $extension = $file->getClientOriginalExtension();
            $filename = 'avatar_' . $adminId . '_' . time() . '.' . $extension;
            
            // 创建上传目录
            $uploadPath = public_path('uploads/avatars');
            if (!is_dir($uploadPath)) {
                mkdir($uploadPath, 0755, true);
            }

            // 移动文件
            $file->move($uploadPath, $filename);
            
            // 生成访问URL
            $avatarUrl = '/uploads/avatars/' . $filename;

            // 更新用户头像
            $admin = AdminsModel::find($adminId);
            if ($admin) {
                // 删除旧头像文件
                if ($admin->avatar && file_exists(public_path($admin->avatar))) {
                    unlink(public_path($admin->avatar));
                }
                
                $admin->update(['avatar' => $avatarUrl]);
            }

            return data(['url' => $avatarUrl], '头像上传成功');
        } catch (\Exception $e) {
            return fail('上传失败：' . $e->getMessage());
        }
    }
}
